package com.zhangxin.aiInterview.manager.work_flow.resume_analyze;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.Data;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 简历分析
 */
public class ResumeAnalyze {
    /**
     * 简历维度信息
     */
    @Data
    public static class DimensionInfo {
        public String name;
        public int score;
        public int maxScore;
        public String reason;
    }

    // 替换为你的API Key 和 API Secret
    private static final String API_KEY = "cd5245ddf5444cfcedd25b57a29b4c0b";
    private static final String API_SECRET = "MzdhNDEzNzVkMDcyZDhhZTM3MWNjODhj";
    private static final String FLOW_ID = "7359809133923655680"; // 工作流 ID

    public static void main(String[] args) {
        analyzeResume("https://zx-1343343346.cos.ap-chongqing.myqcloud.com/ai_interview/resume_pdf/1916016714226561026/zL0fk7Tl-%E5%BC%A0%E9%91%AB-%E7%A7%91%E5%A4%A7%E8%AE%AF%E9%A3%9E-%E5%85%A8%E6%A0%88%E5%BC%80%E5%8F%91.pdf", "前端开发工程师", "百度");
        // 测试extractSummary方法
//        testExtractSummary();
    }

    /**
     * 测试extractSummary方法是否能正确处理各种格式
     */
    private static void testExtractSummary() {
        // 测试数据1：① 序号格式
        String testData1 = "【总结评价】：\n" +
                "1.优势\n" +
                "① 技术栈完全对标企业需求，尤其在Spring生态体系的实践深度超出应届生平均水平，已具备微服务实施能力\n" +
                "② 项目经验丰富且含金量高，包含头部企业实习经历（科大讯飞）、高并发场景优化案例（Disruptor应用）、全流程开发实践（从数据采集到可视化看板）\n" +
                "③ 展现较强的工程化思维，如自主开发数据库表转代码工具、设计动态分片算法等创新尝试\n" +
                "④ 英语CET-6满足外企工作环境需求\n\n" +
                "2.短板与核心建议\n" +
                "① Linux系统操作能力存疑：作为后端开发者必备技能却未在简历体现，建议补充服务器部署/脚本编写等相关经历\n" +
                "② 缺乏体系化的性能调优方法论：现有优化案例多基于单点突破，应补充全链路监控、压力测试等系统性实践\n\n" +
                "3.潜在风险\n" +
                "① 学校背景竞争力不足：在BAT等大厂校招中可能处于劣势，需通过突出项目质量弥补学历短板\n" +
                "② 理论体系不完善：简历显示对JVM调优、分布式事务等高级主题尚未涉及，可能影响中级工程师晋升速度\n\n" +
                "4.简历改进建议\n" +
                "① 新增「技术选型依据」专栏：在每个项目下列明为什么选择特定框架/中间件\n" +
                "② 量化成果指标：将\"提高评分效率\"改为\"批改作业平均耗时从120秒降至18秒（降幅85%）\"\n" +
                "维度权重配置理由：作为技术类岗位...";

        // 测试数据2：- 格式
        String testData2 = "【总结评价】：\n" +
                "1. 优势\n" +
                "   - 技术栈全面且深入：不仅掌握JD要求的Spring Boot/MyBatis等基础框架，还能熟练运用Redis缓存、Spring Cloud微服务等主流解决方案\n" +
                "   - 项目成果量化显著：通过异步编程将接口性能提升近90%，用射线法替代传统算法实现精度跃升\n" +
                "   - 工程化意识突出：自主开发MyBatis-Plus代码生成器大幅提高团队效率，展现工具链整合能力\n\n" +
                "2. 短板与核心建议\n" +
                "   - Linux系统经验空白：JD明确要求掌握Linux操作系统，但简历全程未提及服务器部署\n" +
                "   - 缺乏开源社区参与：虽技术能力强但未在GitHub等平台贡献代码\n\n" +
                "3. 潜在风险\n" +
                "   - 技术路线过于垂直：当前聚焦于Java生态体系，若未来转向云原生架构可能面临挑战\n\n" +
                "4. 简历改进建议\n" +
                "   - 增加「技术选型依据」专栏：在项目描述中补充为何选择CompletableFuture而非其他并发模型\n" +
                "   - 量化管理指标：除\"效率提升80%\"外，可补充具体样本量等维度数据\n" +
                "维度权重配置理由：作为技术类岗位...";

        System.out.println("=== 测试序号格式（①②③④） ===");
        Map<String, String> result1 = extractSummary(testData1);

        System.out.println("\n=== 测试横杠格式（- - -） ===");
        Map<String, String> result2 = extractSummary(testData2);

        System.out.println("\n=== 测试结果汇总 ===");
        String[] sections = { "优势", "短板与核心建议", "潜在风险", "简历改进建议" };

        for (String section : sections) {
            System.out.println("\n【" + section + "】");
            System.out.println("序号格式提取结果长度: " + (result1.get(section) != null ? result1.get(section).length() : 0));
            System.out.println("横杠格式提取结果长度: " + (result2.get(section) != null ? result2.get(section).length() : 0));

            if (result1.get(section) != null) {
                System.out.println("序号格式内容预览: "
                        + (result1.get(section).length() > 100 ? result1.get(section).substring(0, 100) + "..."
                                : result1.get(section)));
            }

            if (result2.get(section) != null) {
                System.out.println("横杠格式内容预览: "
                        + (result2.get(section).length() > 100 ? result2.get(section).substring(0, 100) + "..."
                                : result2.get(section)));
            }
        }
    }

    /**
     * 简历内容提取
     * 
     * @param resumeUrl 简历路径
     * @param position  职位
     * @param company   公司
     */
    public static Map<String, Object> analyzeResume(String resumeUrl, String position, String company) {

        StringBuilder result = new StringBuilder();
        try {
            // 1. 构建请求体 JSON（使用 Hutool）
            JSONObject parameters = new JSONObject();
            // 公司+岗位
            parameters.put("AGENT_USER_INPUT", company + "；" + position);
            parameters.put("pdf", resumeUrl);

            JSONObject requestBody = new JSONObject();
            requestBody.put("flow_id", FLOW_ID);
            requestBody.put("uid", "123");
            requestBody.put("stream", true);
            requestBody.put("parameters", parameters);

            // 2. 构建请求 URL
            URL url = new URL("https://xingchen-api.xf-yun.com/workflow/v1/chat/completions");
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();

            // 3. 设置超时时间（单位：毫秒）
            connection.setConnectTimeout(180000); // 连接超时：3分钟
            connection.setReadTimeout(180000); // 读取超时：3分钟（允许等待更久）

            // 4. 设置请求方法和头部
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json");

            // 设置 Authorization
            String authorizationHeader = "Bearer " + API_KEY + ":" + API_SECRET;
            connection.setRequestProperty("Authorization", authorizationHeader);
            connection.setDoOutput(true);
            // 5. 发送请求数据
            try (OutputStream os = connection.getOutputStream()) {
                byte[] input = requestBody.toString().getBytes(StandardCharsets.UTF_8);
                os.write(input);
            }
            // 6. 读取响应
            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
                    String line;
                    while ((line = br.readLine()) != null) {
                        if (StrUtil.isBlank(line))
                            continue;
                        String content = getContent(line);
                        result.append(content);
                    }
                    System.out.println("Response: " + result);
                    Map<String, Object> map = extractResumeInfo(result.toString());
                    return map;
                }
            } else {
                System.out.println("Error: HTTP " + responseCode);
                try (BufferedReader br = new BufferedReader(new InputStreamReader(connection.getErrorStream()))) {
                    StringBuilder errorResponse = new StringBuilder();
                    String line;
                    while ((line = br.readLine()) != null) {
                        errorResponse.append(line);
                    }
                    System.out.println("Error Response: " + errorResponse);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 处理智能体回复内容格式
     * 
     * @param jsonStr
     * @return
     */
    public static String getContent(String jsonStr) {
        // 去掉前缀 "data: " 并修正格式
        jsonStr = jsonStr.replaceFirst("^data:\\s*", "").trim();

        // 解析为 JSON 对象
        JSONObject jsonObject = JSONUtil.parseObj(jsonStr);

        // 获取 content 字段
        JSONArray choices = jsonObject.getJSONArray("choices");
        JSONObject delta = choices.getJSONObject(0).getJSONObject("delta");
        String content = delta.getStr("content");
        return content;
    }

    /**
     * 简历信息提取
     * 
     * @param content
     * @return
     */
    public static Map<String, Object> extractResumeInfo(String content) {
        Map<String, Object> result = new HashMap<>();

        // 1. 提取维度权重配置理由
        String weightReason = extractWeightReason(content);
        System.out.println("维度权重配置理由：" + weightReason);
        result.put("维度权重配置理由", weightReason);

        // 2. 提取每个维度的得分和理由
        List<DimensionInfo> dimensions = extractDimensions(content);
        result.put("维度得分与理由", dimensions);

        // 3. 提取总结评价的四个部分
        Map<String, String> summary = extractSummary(content);
        result.putAll(summary);

        return result;
    }

    /**
     * 提取维度权重配置理由
     * 
     * @param text
     * @return
     */
    private static String extractWeightReason(String text) {
        Pattern pattern = Pattern.compile(
                "维度权重配置理由[：:]?[\\s\\n]*(.*?)(?=\\n?\\s*【|\\z)",
                Pattern.DOTALL);
        Matcher matcher = pattern.matcher(text);
        return matcher.find() ? matcher.group(1).trim() : null;
    }

    /**
     * 提取每个维度的标题，分数，最高分，原因
     * 
     * @param text
     * @return
     */
    private static List<DimensionInfo> extractDimensions(String text) {
        List<DimensionInfo> result = new ArrayList<>();

        Pattern pattern = Pattern.compile(
                "([\\u4e00-\\u9fa5A-Za-z0-9\\s]+?)[:：]\\s*(\\d{1,3})\\s*/\\s*(\\d{1,3})\\s*-\\s*理由[:：]\\s*(.*?)(?=\\n[\\u4e00-\\u9fa5A-Za-z0-9\\s]+?[:：]\\s*\\d{1,3}\\s*/\\s*\\d{1,3}\\s*-\\s*理由|\\n+【|\\z)",
                Pattern.DOTALL);

        Matcher matcher = pattern.matcher(text);
        while (matcher.find()) {
            DimensionInfo info = new DimensionInfo();
            info.name = matcher.group(1).trim();
            info.score = Integer.parseInt(matcher.group(2).trim());
            info.maxScore = Integer.parseInt(matcher.group(3).trim());
            info.reason = matcher.group(4).replaceAll("\\s+", " ").trim();

            // 调试输出
            System.out.println("维度名称：" + info.name);
            System.out.println("实际得分：" + info.score);
            System.out.println("满分：" + info.maxScore);
            System.out.println("原因说明：" + info.reason);

            result.add(info);
        }

        return result;
    }

    /**
     * 提取优势、短板与核心建议、潜在风险、简历改进建议
     * 
     * @param text
     * @return
     */
    private static Map<String, String> extractSummary(String text) {
        Map<String, String> result = new LinkedHashMap<>();
        String[] sections = { "优势", "短板与核心建议", "潜在风险", "简历改进建议" };

        // 提取总结部分内容
        int summaryStart = text.indexOf("【总结评价】");
        if (summaryStart == -1)
            return result;

        String summaryText = text.substring(summaryStart);

        for (int i = 0; i < sections.length; i++) {
            String current = sections[i];
            String next = (i + 1 < sections.length) ? sections[i + 1] : null;

            // 直接使用改进的提取方法
            String content = extractSectionContent(summaryText, current, next, i + 1);
            if (content != null && !content.trim().isEmpty()) {
                result.put(current, content);
                System.out.println(current + "：" + content);
            } else {
                result.put(current, null);
                System.out.println(current + "：匹配失败");
            }
        }
        return result;
    }

    /**
     * 提取指定部分的内容（改进版本）
     */
    private static String extractSectionContent(String text, String current, String next, int sectionNumber) {
        try {
            System.out.println("=== 开始提取: " + current + " (编号: " + sectionNumber + ") ===");

            // 查找当前部分的开始位置，支持多种格式
            int startPos = -1;
            int contentStartPos = -1;

            // 尝试匹配格式1：数字. 标题（如：1. 优势）
            String pattern1 = "(?:^|\\n)\\s*" + sectionNumber + "\\.\\s*" + Pattern.quote(current);
            Pattern p1 = Pattern.compile(pattern1, Pattern.MULTILINE);
            Matcher m1 = p1.matcher(text);
            if (m1.find()) {
                startPos = m1.start();
                contentStartPos = m1.end();
                System.out.println("使用格式1匹配成功: " + pattern1);
                System.out.println("匹配到的文本: [" + m1.group() + "]");
            }

            // 如果格式1没找到，尝试格式2：数字标题（如：1优势）
            if (startPos == -1) {
                String pattern2 = "(?:^|\\n)\\s*" + sectionNumber + "\\s*" + Pattern.quote(current);
                Pattern p2 = Pattern.compile(pattern2, Pattern.MULTILINE);
                Matcher m2 = p2.matcher(text);
                if (m2.find()) {
                    startPos = m2.start();
                    contentStartPos = m2.end();
                    System.out.println("使用格式2匹配成功: " + pattern2);
                    System.out.println("匹配到的文本: [" + m2.group() + "]");
                }
            }

            // 如果前两种都没找到，尝试格式3：直接标题（如：优势）
            if (startPos == -1) {
                String pattern3 = "(?:^|\\n)\\s*" + Pattern.quote(current);
                Pattern p3 = Pattern.compile(pattern3, Pattern.MULTILINE);
                Matcher m3 = p3.matcher(text);
                if (m3.find()) {
                    startPos = m3.start();
                    contentStartPos = m3.end();
                    System.out.println("使用格式3匹配成功: " + pattern3);
                    System.out.println("匹配到的文本: [" + m3.group() + "]");
                }
            }

            if (startPos == -1) {
                System.out.println("未找到 " + current + " 的开始位置");
                return null;
            }

            System.out.println("内容开始位置: " + contentStartPos);

            // 确定结束位置
            int endPos = text.length();

            if (next != null) {
                // 查找下一个主要部分的开始位置
                int nextSectionNumber = sectionNumber + 1;

                // 尝试多种格式查找下一个部分
                String[] nextPatterns = {
                        "(?:^|\\n)\\s*" + nextSectionNumber + "\\.\\s*" + Pattern.quote(next),
                        "(?:^|\\n)\\s*" + nextSectionNumber + "\\s*" + Pattern.quote(next),
                        "(?:^|\\n)\\s*" + Pattern.quote(next)
                };

                for (String nextPattern : nextPatterns) {
                    Pattern nextP = Pattern.compile(nextPattern, Pattern.MULTILINE);
                    Matcher nextMatcher = nextP.matcher(text);
                    if (nextMatcher.find(contentStartPos)) {
                        endPos = nextMatcher.start();
                        System.out.println("找到下一个部分 [" + next + "] 位置: " + endPos);
                        System.out.println("使用模式: " + nextPattern);
                        break;
                    }
                }

                if (endPos == text.length()) {
                    System.out.println("未找到下一个部分，使用文本结尾");
                }
            } else {
                // 最后一个部分，查找"维度权重配置理由"的位置
                int reasonStart = text.indexOf("维度权重配置理由：", contentStartPos);
                if (reasonStart != -1) {
                    endPos = reasonStart;
                    System.out.println("找到维度权重配置理由位置: " + endPos);
                }
            }

            // 提取内容
            if (contentStartPos >= endPos) {
                System.out.println("内容位置异常: contentStartPos=" + contentStartPos + ", endPos=" + endPos);
                return null;
            }

            String content = text.substring(contentStartPos, endPos).trim();
            System.out.println("原始提取内容长度: " + content.length());
            System.out.println(
                    "原始提取内容前100字符: [" + (content.length() > 100 ? content.substring(0, 100) + "..." : content) + "]");

            String cleanedContent = cleanContent(content);
            System.out.println("清理后内容长度: " + (cleanedContent != null ? cleanedContent.length() : 0));
            System.out.println("=== 提取完成: " + current + " ===\n");

            return cleanedContent;

        } catch (Exception e) {
            System.out.println("提取" + current + "失败: " + e.getMessage());
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 清理内容，去掉可能的编号前缀和多余空白
     */
    private static String cleanContent(String content) {
        if (content == null || content.trim().isEmpty())
            return null;

        // 去掉开头可能的冒号或换行
        content = content.trim();
        if (content.startsWith("：") || content.startsWith(":")) {
            content = content.substring(1).trim();
        }

        // 去掉可能的开头换行
        while (content.startsWith("\n") || content.startsWith("\r")) {
            content = content.substring(1).trim();
        }

        // 去掉结尾可能的"维度权重配置理由："重复内容
        if (content.contains("维度权重配置理由：")) {
            int index = content.indexOf("维度权重配置理由：");
            content = content.substring(0, index).trim();
        }

        return content.trim();
    }

}